home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 201-225 / disk_222 / plplot / src / source.zoo / global.c < prev    next >
C/C++ Source or Header  |  1989-05-15  |  6KB  |  444 lines
  1. /* Sets and gets global variables */
  2.  
  3. #include "plplot.h"
  4. #include "declare.h"
  5.  
  6. void glev(n)
  7. int *n;
  8. {
  9.       *n = level;
  10. }
  11.  
  12. void slev(n)
  13. int n;
  14. {
  15.       level = n;
  16. }
  17.  
  18. void gbase(x,y,xc,yc)
  19. float *x,*y,*xc,*yc;
  20. {
  21.       *x = base3x;
  22.       *y = base3y;
  23.       *xc = basecx;
  24.       *yc = basecy;
  25. }
  26.  
  27. void sbase(x,y,xc,yc)
  28. float x,y,xc,yc;
  29. {
  30.       base3x = x;
  31.       base3y = y;
  32.       basecx = xc;
  33.       basecy = yc;
  34. }
  35.  
  36. void gnms(n)
  37. int *n;
  38. {
  39.       *n = nms;
  40. }
  41.  
  42. void snms(n)
  43. int n;
  44. {
  45.       nms = n;
  46. }
  47.  
  48. void gdev(dev,term,gra)
  49. int *dev,*term,*gra;
  50. {
  51.       *dev = device;
  52.       *term = termin;
  53.       *gra = graphx;
  54. }
  55.  
  56. void sdev(dev,term,gra)
  57. int dev,term,gra;
  58. {
  59.       device = dev;
  60.       termin = term;
  61.       graphx = gra;
  62. }
  63.  
  64. void gcurr(ix,iy)
  65. int *ix,*iy;
  66. {
  67.       *ix = currx;
  68.       *iy = curry;
  69. }
  70.  
  71. void scurr(ix,iy)
  72. int ix,iy;
  73. {
  74.       currx = ix;
  75.       curry = iy;
  76. }
  77.  
  78. void gdom(xmin,xmax,ymin,ymax)
  79. float *xmin,*xmax,*ymin,*ymax;
  80. {
  81.       *xmin = domxmi;
  82.       *xmax = domxma;
  83.       *ymin = domymi;
  84.       *ymax = domyma;
  85. }
  86.  
  87. void sdom(xmin,xmax,ymin,ymax)
  88. float xmin,xmax,ymin,ymax;
  89. {
  90.       domxmi = xmin;
  91.       domxma = xmax;
  92.       domymi = ymin;
  93.       domyma = ymax;
  94. }
  95.  
  96. void grange(zscl,zmin,zmax)
  97. float *zscl,*zmin,*zmax;
  98. {
  99.       *zscl = zzscl;
  100.       *zmin = ranmi;
  101.       *zmax = ranma;
  102. }
  103.  
  104. void srange(zscl,zmin,zmax)
  105. float zscl,zmin,zmax;
  106. {
  107.       zzscl = zscl;
  108.       ranmi = zmin;
  109.       ranma = zmax;
  110. }
  111.  
  112. void gw3wc(dxx,dxy,dyx,dyy,dyz)
  113. float *dxx,*dxy,*dyx,*dyy,*dyz;
  114. {
  115.       *dxx = cxx;
  116.       *dxy = cxy;
  117.       *dyx = cyx;
  118.       *dyy = cyy;
  119.       *dyz = cyz;
  120. }
  121.  
  122. void sw3wc(dxx,dxy,dyx,dyy,dyz)
  123. float dxx,dxy,dyx,dyy,dyz;
  124. {
  125.       cxx = dxx;
  126.       cxy = dxy;
  127.       cyx = dyx;
  128.       cyy = dyy;
  129.       cyz = dyz;
  130. }
  131.  
  132. void gvpp(ixmin,ixmax,iymin,iymax)
  133. int *ixmin,*ixmax,*iymin,*iymax;
  134. {
  135.       *ixmin = vppxmi;
  136.       *ixmax = vppxma;
  137.       *iymin = vppymi;
  138.       *iymax = vppyma;
  139. }
  140.  
  141. void svpp(ixmin,ixmax,iymin,iymax)
  142. int ixmin,ixmax,iymin,iymax;
  143. {
  144.       vppxmi = ixmin;
  145.       vppxma = ixmax;
  146.       vppymi = iymin;
  147.       vppyma = iymax;
  148. }
  149.  
  150. void gspp(ixmin,ixmax,iymin,iymax)
  151. int *ixmin,*ixmax,*iymin,*iymax;
  152. {
  153.       *ixmin = sppxmi;
  154.       *ixmax = sppxma;
  155.       *iymin = sppymi;
  156.       *iymax = sppyma;
  157. }
  158.  
  159. void sspp(ixmin,ixmax,iymin,iymax)
  160. int ixmin,ixmax,iymin,iymax;
  161. {
  162.       sppxmi = ixmin;
  163.       sppxma = ixmax;
  164.       sppymi = iymin;
  165.       sppyma = iymax;
  166. }
  167.  
  168. void gclp(ixmin,ixmax,iymin,iymax)
  169. int *ixmin,*ixmax,*iymin,*iymax;
  170. {
  171.       *ixmin = clpxmi;
  172.       *ixmax = clpxma;
  173.       *iymin = clpymi;
  174.       *iymax = clpyma;
  175. }
  176.  
  177. void sclp(ixmin,ixmax,iymin,iymax)
  178. int ixmin,ixmax,iymin,iymax;
  179. {
  180.       clpxmi = ixmin;
  181.       clpxma = ixmax;
  182.       clpymi = iymin;
  183.       clpyma = iymax;
  184. }
  185.  
  186. void gphy(ixmin,ixmax,iymin,iymax)
  187. int *ixmin,*ixmax,*iymin,*iymax;
  188. {
  189.       *ixmin = phyxmi;
  190.       *ixmax = phyxma;
  191.       *iymin = phyymi;
  192.       *iymax = phyyma;
  193. }
  194.  
  195. void sphy(ixmin,ixmax,iymin,iymax)
  196. int ixmin,ixmax,iymin,iymax;
  197. {
  198.       phyxmi = ixmin;
  199.       phyxma = ixmax;
  200.       phyymi = iymin;
  201.       phyyma = iymax;
  202. }
  203.  
  204. void gsub(nx,ny,cs)
  205. int *nx,*ny,*cs;
  206. {
  207.       *nx = nsubx;
  208.       *ny = nsuby;
  209.       *cs = cursub;
  210. }
  211.  
  212. void ssub(nx,ny,cs)
  213. int nx,ny,cs;
  214. {
  215.       nsubx = nx;
  216.       nsuby = ny;
  217.       cursub = cs;
  218. }
  219.  
  220. void gumpix(ix,iy)
  221. int *ix,*iy;
  222. {
  223.       *ix = umx;
  224.       *iy = umy;
  225. }
  226.  
  227. void sumpix(ix,iy)
  228. int ix,iy;
  229. {
  230.       umx = ix;
  231.       umy = iy;
  232. }
  233.  
  234. void gatt(ifnt,icol)
  235. int *ifnt,*icol;
  236. {
  237.       *ifnt = font;
  238.       *icol = colour;
  239. }
  240.  
  241. void satt(ifnt,icol)
  242. int ifnt,icol;
  243. {
  244.       font = ifnt;
  245.       colour = icol;
  246. }
  247.  
  248. void gspd(xmin,xmax,ymin,ymax)
  249. float *xmin,*xmax,*ymin,*ymax;
  250. {
  251.       *xmin = spdxmi;
  252.       *xmax = spdxma;
  253.       *ymin = spdymi;
  254.       *ymax = spdyma;
  255. }
  256.  
  257. void sspd(xmin,xmax,ymin,ymax)
  258. float xmin,xmax,ymin,ymax;
  259. {
  260.       spdxmi = xmin;
  261.       spdxma = xmax;
  262.       spdymi = ymin;
  263.       spdyma = ymax;
  264. }
  265.  
  266. void gvpd(xmin,xmax,ymin,ymax)
  267. float *xmin,*xmax,*ymin,*ymax;
  268. {
  269.       *xmin = vpdxmi;
  270.       *xmax = vpdxma;
  271.       *ymin = vpdymi;
  272.       *ymax = vpdyma;
  273. }
  274.  
  275. void svpd(xmin,xmax,ymin,ymax)
  276. float xmin,xmax,ymin,ymax;
  277. {
  278.       vpdxmi = xmin;
  279.       vpdxma = xmax;
  280.       vpdymi = ymin;
  281.       vpdyma = ymax;
  282. }
  283.  
  284. void gvpw(xmin,xmax,ymin,ymax)
  285. float *xmin,*xmax,*ymin,*ymax;
  286. {
  287.       *xmin = vpwxmi;
  288.       *xmax = vpwxma;
  289.       *ymin = vpwymi;
  290.       *ymax = vpwyma;
  291. }
  292.  
  293. void svpw(xmin,xmax,ymin,ymax)
  294. float xmin,xmax,ymin,ymax;
  295. {
  296.       vpwxmi = xmin;
  297.       vpwxma = xmax;
  298.       vpwymi = ymin;
  299.       vpwyma = ymax;
  300. }
  301.  
  302. void gpixmm(x,y)
  303. float *x,*y;
  304. {
  305.       *x = xpmm;
  306.       *y = ypmm;
  307. }
  308.  
  309. void spixmm(x,y)
  310. float x,y;
  311. {
  312.       xpmm = x;
  313.       ypmm = y;
  314. }
  315.  
  316. void gwp(xscl,xoff,yscl,yoff)
  317. float *xscl,*xoff,*yscl,*yoff;
  318. {
  319.       *xscl = wpxscl;
  320.       *xoff = wpxoff;
  321.       *yscl = wpyscl;
  322.       *yoff = wpyoff;
  323. }
  324.  
  325. void swm(xscl,xoff,yscl,yoff)
  326. float xscl,xoff,yscl,yoff;
  327. {
  328.       wmxscl = xscl;
  329.       wmxoff = xoff;
  330.       wmyscl = yscl;
  331.       wmyoff = yoff;
  332. }
  333.  
  334. void gwm(xscl,xoff,yscl,yoff)
  335. float *xscl,*xoff,*yscl,*yoff;
  336. {
  337.       *xscl = wmxscl;
  338.       *xoff = wmxoff;
  339.       *yscl = wmyscl;
  340.       *yoff = wmyoff;
  341. }
  342.  
  343. void swp(xscl,xoff,yscl,yoff)
  344. float xscl,xoff,yscl,yoff;
  345. {
  346.       wpxscl = xscl;
  347.       wpxoff = xoff;
  348.       wpyscl = yscl;
  349.       wpyoff = yoff;
  350. }
  351.  
  352. void gdp(xscl,xoff,yscl,yoff)
  353. float *xscl,*xoff,*yscl,*yoff;
  354. {
  355.       *xscl = dpxscl;
  356.       *xoff = dpxoff;
  357.       *yscl = dpyscl;
  358.       *yoff = dpyoff;
  359. }
  360.  
  361. void sdp(xscl,xoff,yscl,yoff)
  362. float xscl,xoff,yscl,yoff;
  363. {
  364.       dpxscl = xscl;
  365.       dpxoff = xoff;
  366.       dpyscl = yscl;
  367.       dpyoff = yoff;
  368. }
  369.  
  370. void gmp(xscl,xoff,yscl,yoff)
  371. float *xscl,*xoff,*yscl,*yoff;
  372. {
  373.       *xscl = mpxscl;
  374.       *xoff = mpxoff;
  375.       *yscl = mpyscl;
  376.       *yoff = mpyoff;
  377. }
  378.  
  379. void smp(xscl,xoff,yscl,yoff)
  380. float xscl,xoff,yscl,yoff;
  381. {
  382.       mpxscl = xscl;
  383.       mpxoff = xoff;
  384.       mpyscl = yscl;
  385.       mpyoff = yoff;
  386. }
  387.             
  388. void gchr(def,ht)
  389. float *def,*ht;
  390. {
  391.       *def = chrdef;
  392.       *ht = chrht;
  393. }
  394.             
  395. void schr(def,ht)
  396. float def,ht;
  397. {
  398.       chrdef = def;
  399.       chrht = ht;
  400. }
  401.             
  402. void gsym(def,ht)
  403. float *def,*ht;
  404. {
  405.       *def = symdef;
  406.       *ht = symht;
  407. }
  408.             
  409. void ssym(def,ht)
  410. float def,ht;
  411. {
  412.       symdef = def;
  413.       symht = ht;
  414. }
  415.             
  416. void gmaj(def,ht)
  417. float *def,*ht;
  418. {
  419.       *def = majdef;
  420.       *ht = majht;
  421. }
  422.             
  423. void smaj(def,ht)
  424. float def,ht;
  425. {
  426.       majdef = def;
  427.       majht = ht;
  428. }
  429.             
  430. void gmin(def,ht)
  431. float *def,*ht;
  432. {
  433.       *def = mindef;
  434.       *ht = minht;
  435. }
  436.             
  437. void smin(def,ht)
  438. float def,ht;
  439. {
  440.       mindef = def;
  441.       minht = ht;
  442. }
  443.  
  444.